#ifndef TASK_CHANNEL_H
#define TASK_CHANNEL_H

#include "copy/noncopyable.h"

#include <functional>

class EventLoop;

class Channel : muduo::noncopyable{
public:
    typedef std::function<void()> EventCallback;
    // 对应的回调函数

    Channel(EventLoop * loop, int fd);
    // 加入事件池和对应负责的文件描述符, 自始至终只负责这个文件描述符上的事件的分发

    /**
     * 对应事件发生时调用对应回调函数
     */
    void handleEvent();

    void setReadCallback(const EventCallback &readCallback) {
        readCallback_ = readCallback;
    }

    void setWriteCallback(const EventCallback &writeCallback) {
        writeCallback_ = writeCallback;
    }

    void setErrorCallback(const EventCallback &errorCallback) {
        errorCallback_ = errorCallback;
    }

    /**
     * 返回对应负责的文件描述符
     */
    int  fd() const{
        return fd_;
    }

    /**
     * 返回要监视的事件
     */
    int events() const{
        return events_;
    }

    void set_revents(int revt){
        revents_ = revt;
    }

    bool isNoneEvent() const{
        return events_ == kNoneEvent;
    }

    void enableReading(){
        events_ |= kReadEvent;
        update();
    }

    void enableWriting(){
        events_ |= kWriteEvent;
        update();
    }

    void disableWriting(){
        events_ &= ~kWriteEvent;
        update();
    }

    void disableAll(){
        events_ = kNoneEvent;
        update();
    }

    int index() const{
        return index_;
    }

    void set_index(int index){
        index_ = index;
    }

    EventLoop * ownerLoop(){
        return loop_;
    }


private:
    void update();

    static const int kNoneEvent;
    static const int kReadEvent;
    static const int kWriteEvent;

    EventLoop * loop_;
    const int fd_;
    int events_;
    // 这个Channel类关心的事件
    int revents_;
    // 当前活动的事件
    int index_;

    EventCallback readCallback_;
    EventCallback writeCallback_;
    EventCallback errorCallback_;
};

#endif //TASK_CHANNEL_H
